JavaScripti dekoraatorid parameetrite valideerimiseks: Andmete terviklikkuse tagamine

Kaasaegses JavaScripti arenduses on funktsioonidele ja meetoditele edastatavate andmete terviklikkuse tagamine ülimalt oluline. Üks võimas tehnika selle saavutamiseks on dekoraatorite kasutamine parameetrite valideerimiseks. Dekoraatorid, mis on JavaScriptis saadaval Babeli kaudu või TypeScriptis loomulikult, pakuvad puhast ja elegantset viisi funktsioonidele, klassidele ja omadustele funktsionaalsuse lisamiseks. See artikkel süveneb JavaScripti dekoraatorite maailma, keskendudes konkreetselt nende rakendamisele argumentide kontrollimisel, pakkudes praktilisi näiteid ja teadmisi igal tasemel arendajatele.

Mis on JavaScripti dekoraatorid?

Dekoraatorid on disainimuster, mis võimaldab teil dünaamiliselt ja staatiliselt lisada käitumist olemasolevale klassile, funktsioonile või omadusele. Sisuliselt nad "kaunistavad" olemasolevat koodi uue funktsionaalsusega, muutmata algset koodi ennast. See järgib SOLID-disaini avatud/suletud põhimõtet, mis ütleb, et tarkvaraüksused (klassid, moodulid, funktsioonid jne) peaksid olema avatud laiendamiseks, kuid suletud muutmiseks.

JavaScriptis on dekoraatorid erilist tüüpi deklaratsioonid, mida saab lisada klassi deklaratsioonile, meetodile, pääsumeetodile, omadusele või parameetrile. Nad kasutavad süntaksit @expression, kus expression peab hindama funktsiooniks, mis käivitatakse käitusajal koos teabega dekoreeritud deklaratsiooni kohta.

JavaScriptis dekoraatorite kasutamiseks on tavaliselt vaja kasutada transpilerit nagu Babel koos lubatud @babel/plugin-proposal-decorators pluginaga. TypeScript toetab dekoraatoreid loomulikult.

Dekoraatorite kasutamise eelised parameetrite valideerimisel

Dekoraatorite kasutamine parameetrite valideerimiseks pakub mitmeid eeliseid:

• Parem koodi loetavus: Dekoraatorid pakuvad deklaratiivset viisi valideerimisreeglite väljendamiseks, muutes koodi lihtsamini mõistetavaks ja hooldatavaks.
• Vähem korduvkoodi: Selle asemel, et korrata valideerimisloogikat mitmes funktsioonis, võimaldavad dekoraatorid selle defineerida üks kord ja rakendada seda kogu oma koodibaasis.
• Parem koodi taaskasutatavus: Dekoraatoreid saab taaskasutada erinevates klassides ja funktsioonides, edendades koodi taaskasutamist ja vähendades liiasust.
• Vastutusalade eraldamine: Valideerimisloogika on eraldatud funktsiooni põhiäriloogikast, mis viib puhtama ja modulaarsema koodini.
• Tsentraliseeritud valideerimisloogika: Kõik valideerimisreeglid on defineeritud ühes kohas, mis teeb nende uuendamise ja hooldamise lihtsamaks.

Parameetrite valideerimise rakendamine dekoraatoritega

Uurime, kuidas rakendada parameetrite valideerimist JavaScripti dekoraatorite abil. Alustame lihtsa näitega ja liigume seejärel keerukamate stsenaariumide juurde.

Lihtne näide: Sõneparameetri valideerimine

Vaatleme funktsiooni, mis ootab sõneparameetrit. Saame luua dekoraatori, et tagada parameetri tõepoolest sõneks olemine.

function validateString(target: any, propertyKey: string | symbol, parameterIndex: number) {
  let existingParameters: any[] = Reflect.getOwnMetadata('validateParameters', target, propertyKey) || [];
  existingParameters.push({ index: parameterIndex, validator: (value: any) => typeof value === 'string' });
  Reflect.defineMetadata('validateParameters', existingParameters, target, propertyKey);

  const originalMethod = target[propertyKey];

  target[propertyKey] = function (...args: any[]) {
    const metadata = Reflect.getOwnMetadata('validateParameters', target, propertyKey);

    if (metadata) {
      for (const item of metadata) {
        const { index, validator } = item;
        if (!validator(args[index])) {
          throw new Error(`Parameter at index ${index} is invalid`);
        }
      }
    }

    return originalMethod.apply(this, args);
  };
}

function validate(...validators: ((value: any) => boolean)[]) {
  return function (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) {
    const originalMethod = descriptor.value;

    descriptor.value = function (...args: any[]) {
      for (let i = 0; i < validators.length; i++) {
        if (!validators[i](args[i])) {
          throw new Error(`Parameter at index ${i} is invalid`);
        }
      }
      return originalMethod.apply(this, args);
    };
  };
}


function isString(value: any): boolean {
  return typeof value === 'string';
}

class Example {
  @validate(isString)
  greet( @validateString name: string) {
    return `Hello, ${name}!`;
  }
}

const example = new Example();

try {
  console.log(example.greet("Alice")); // Output: Hello, Alice!
  // example.greet(123); // Throws an error
} catch (error:any) {
  console.error(error.message);
}

Selgitus:

• Dekoraator validateString rakendatakse meetodi greet parameetrile name.
• See kasutab Reflect.defineMetadata ja Reflect.getOwnMetadata, et salvestada ja hankida meetodiga seotud valideerimise metaandmeid.
• Enne algse meetodi käivitamist itereerib see läbi valideerimise metaandmete ja rakendab valideerimisfunktsiooni igale parameetrile.
• Kui mõni parameeter valideerimist ei läbi, visatakse viga.
• Dekoraator validate pakub üldisemat ja komponeeritavamat viisi validaatorite rakendamiseks parameetritele, võimaldades määrata igale parameetrile mitu validaatorit.
• Funktsioon isString on lihtne validaator, mis kontrollib, kas väärtus on sõne.
• Klass Example demonstreerib, kuidas kasutada dekoraatoreid meetodi greet parameetri name valideerimiseks.

Keerulisem näide: E-posti vormingu valideerimine

Loome dekoraatori, et valideerida, kas sõneparameeter on kehtiv e-posti aadress.

function validateEmail(target: any, propertyKey: string | symbol, parameterIndex: number) {
  let existingParameters: any[] = Reflect.getOwnMetadata('validateParameters', target, propertyKey) || [];
  existingParameters.push({ index: parameterIndex, validator: (value: any) => {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return typeof value === 'string' && emailRegex.test(value);
  } });
  Reflect.defineMetadata('validateParameters', existingParameters, target, propertyKey);

  const originalMethod = target[propertyKey];

  target[propertyKey] = function (...args: any[]) {
    const metadata = Reflect.getOwnMetadata('validateParameters', target, propertyKey);

    if (metadata) {
      for (const item of metadata) {
        const { index, validator } = item;
        if (!validator(args[index])) {
          throw new Error(`Parameter at index ${index} is not a valid email address`);
        }
      }
    }

    return originalMethod.apply(this, args);
  };
}

class User {
  register( @validateEmail email: string) {
    return `Registered with email: ${email}`;
  }
}

const user = new User();

try {
  console.log(user.register("test@example.com")); // Output: Registered with email: test@example.com
  // user.register("invalid-email"); // Throws an error
} catch (error:any) {
  console.error(error.message);
}

Selgitus:

• Dekoraator validateEmail kasutab regulaaravaldist, et kontrollida, kas parameeter on kehtiv e-posti aadress.
• Kui parameeter ei ole kehtiv e-posti aadress, visatakse viga.

Mitu validaatori kombineerimine

Saate kombineerida mitut validaatorit, kasutades dekoraatorit validate ja kohandatud valideerimisfunktsioone.

function isNotEmptyString(value: any): boolean {
  return typeof value === 'string' && value.trim() !== '';
}

function isPositiveNumber(value: any): boolean {
  return typeof value === 'number' && value > 0;
}

class Product {
  @validate(isNotEmptyString, isPositiveNumber)
  create(name: string, price: number) {
    return `Product created: ${name} - $${price}`;
  }
}

const product = new Product();

try {
  console.log(product.create("Laptop", 1200)); // Output: Product created: Laptop - $1200
  // product.create("", 0); // Throws an error
} catch (error:any) {
  console.error(error.message);
}

Selgitus:

• Validaator isNotEmptyString kontrollib, kas sõne ei ole pärast tühikute eemaldamist tühi.
• Validaator isPositiveNumber kontrollib, kas väärtus on positiivne arv.
• Dekoraatorit validate kasutatakse mõlema validaatori rakendamiseks klassi Product meetodile create.

Parimad praktikad dekoraatorite kasutamisel parameetrite valideerimiseks

Siin on mõned parimad praktikad, mida tuleks kaaluda dekoraatorite kasutamisel parameetrite valideerimiseks:

• Hoidke dekoraatorid lihtsad: Dekoraatorid peaksid keskenduma valideerimisloogikale ja vältima keerulisi arvutusi.
• Pakkuge selgeid veateateid: Veenduge, et veateated oleksid informatiivsed ja aitaksid arendajatel mõista valideerimise ebaõnnestumisi.
• Kasutage tähendusrikkaid nimesid: Valige oma dekoraatoritele kirjeldavad nimed, et parandada koodi loetavust.
• Dokumenteerige oma dekoraatorid: Dokumenteerige oma dekoraatorite eesmärk ja kasutus, et neid oleks lihtsam mõista ja hooldada.
• Arvestage jõudlusega: Kuigi dekoraatorid pakuvad mugavat viisi funktsionaalsuse lisamiseks, olge teadlik nende jõudlusmõjust, eriti jõudluskriitilistes rakendustes.
• Kasutage TypeScripti parema tüübiohutuse tagamiseks: TypeScript pakub sisseehitatud tuge dekoraatoritele ja parandab tüübiohutust, muutes dekoraatoritel põhineva valideerimisloogika arendamise ja hooldamise lihtsamaks.
• Testige oma dekoraatoreid põhjalikult: Kirjutage ühikteste, et tagada oma dekoraatorite korrektne toimimine ja erinevate stsenaariumide asjakohane käsitlemine.

Reaalse maailma näited ja kasutusjuhud

Siin on mõned reaalse maailma näited, kuidas dekoraatoreid saab kasutada parameetrite valideerimiseks:

• API päringute valideerimine: Dekoraatoreid saab kasutada sissetulevate API päringute parameetrite valideerimiseks, tagades, et need vastavad oodatud andmetüüpidele ja vormingutele. See hoiab ära ootamatu käitumise teie taustaprogrammi loogikas. Kujutage ette stsenaariumi, kus API lõpp-punkt ootab kasutaja registreerimispäringut parameetritega nagu username, email ja password. Dekoraatoreid saab kasutada valideerimiseks, et need parameetrid on olemas, õiget tüüpi (sõne) ja vastavad kindlatele vormingutele (nt e-posti aadressi valideerimine regulaaravaldisega).
• Vormi sisendi valideerimine: Dekoraatoreid saab kasutada vormi sisestusväljade valideerimiseks, tagades, et kasutajad sisestavad kehtivaid andmeid. Näiteks valideerides, et postiindeksi väli sisaldab teatud riigi jaoks kehtivat postiindeksi vormingut.
• Andmebaasi päringute valideerimine: Dekoraatoreid saab kasutada andmebaasi päringutele edastatud parameetrite valideerimiseks, vältides SQL-i süstimise haavatavusi. Tagades, et kasutaja esitatud andmed on enne andmebaasipäringus kasutamist korralikult puhastatud. See võib hõlmata andmetüüpide, pikkuste ja vormingute kontrollimist ning erimärkide põgenemist pahatahtliku koodi süstimise vältimiseks.
• Konfiguratsioonifailide valideerimine: Dekoraatoreid saab kasutada konfiguratsioonifailide sätete valideerimiseks, tagades, et need on vastuvõetavates vahemikes ja õiget tüüpi.
• Andmete serialiseerimine/deserialiseerimine: Dekoraatoreid saab kasutada andmete valideerimiseks serialiseerimis- ja deserialiseerimisprotsesside ajal, tagades andmete terviklikkuse ja vältides andmete riknemist. JSON-andmete struktuuri valideerimine enne nende töötlemist, jõustades nõutud väljad, andmetüübid ja vormingud.

Dekoraatorite võrdlus teiste valideerimistehnikatega

Kuigi dekoraatorid on võimas tööriist parameetrite valideerimiseks, on oluline mõista nende tugevusi ja nõrkusi võrreldes teiste valideerimistehnikatega:

• Käsitsi valideerimine: Käsitsi valideerimine hõlmab valideerimisloogika kirjutamist otse funktsioonidesse. See lähenemine võib olla tüütu ja vigadele aldis, eriti keeruliste valideerimisreeglite puhul. Dekoraatorid pakuvad deklaratiivsemat ja taaskasutatavamat lähenemist.
• Valideerimisteegid: Valideerimisteegid pakuvad komplekti eelnevalt ehitatud valideerimisfunktsioone ja -reegleid. Kuigi need teegid võivad olla kasulikud, ei pruugi nad olla nii paindlikud või kohandatavad kui dekoraatorid. Teegid nagu Joi või Yup on suurepärased skeemide defineerimiseks tervete objektide valideerimiseks, samas kui dekoraatorid paistavad silma üksikute parameetrite valideerimisel.
• Vahevara: Vahevara kasutatakse sageli päringute valideerimiseks veebirakendustes. Kuigi vahevara sobib tervete päringute valideerimiseks, saab dekoraatoreid kasutada üksikute funktsiooniparameetrite peeneteralisemaks valideerimiseks.

Kokkuvõte

JavaScripti dekoraatorid pakuvad võimsat ja elegantset viisi parameetrite valideerimise rakendamiseks. Dekoraatorite abil saate parandada koodi loetavust, vähendada korduvkoodi, suurendada koodi taaskasutatavust ja eraldada valideerimisloogika põhiäriloogikast. Olenemata sellest, kas ehitate API-sid, veebirakendusi või muud tüüpi tarkvara, aitavad dekoraatorid teil tagada andmete terviklikkuse ning luua vastupidavamat ja hooldatavamat koodi.

Dekoraatoreid uurides pidage meeles järgida parimaid praktikaid, kaaluda reaalse maailma näiteid ja võrrelda dekoraatoreid teiste valideerimistehnikatega, et leida oma konkreetsetele vajadustele parim lähenemine. Tugeva arusaamisega dekoraatoritest ja nende rakendamisest parameetrite valideerimisel saate oluliselt parandada oma JavaScripti koodi kvaliteeti ja usaldusväärsust.

Lisaks muudab TypeScripti kasvav kasutuselevõtt, mis pakub dekoraatoritele loomulikku tuge, selle tehnika veelgi köitvamaks kaasaegse JavaScripti arenduse jaoks. Dekoraatorite omaksvõtmine parameetrite valideerimiseks on samm puhtamate, hooldatavamate ja vastupidavamate JavaScripti rakenduste kirjutamise suunas.